

<!DOCTYPE html>
<html lang="en">

<head>
  <meta charset="UTF-8">
  <meta name="viewport" content="width=device-width, initial-scale=1.0">
  <title>Document</title>
    <style>
    /* base */
    html,
    body,
    .container {
      width: 100%;
      height: 100%;
    }

    a,
    a:link,
    a:visited {
      text-decoration: none;
      color: inherit;
    }

    ul {
      list-style: none;
    }

    *,
    ::before,
    ::after {
      box-sizing: border-box;
      margin: 0;
      padding: 0;
    }

    *:focus {
      outline: 0;
    }

    .container {
      display: flex;
      padding-top: 20px;
    }

    /* Nav */
    .container .doc-nav {
      position: fixed;
      height: 100%;
      margin: 0 30px 0 40px;
      width: 280px;
    }

    .doc-nav .nav-header {
      display: flex;
      align-items: center;
      box-sizing: border-box;
      background-color: rgb(240, 241, 242);
      height: 40px;
      padding: 16px;
      font-size: 18px;
      font-weight: 500;
      color: rgb(62, 64, 66);
      cursor: pointer;
    }

    .doc-nav .nav-content {
      height: calc(100% - 40px);
      overflow-y: auto;
      color: rgb(32, 34, 36);
    }

    .doc-nav .nav-content .nav-list,
    .doc-nav .nav-content .nav-sub-list {
      line-height: 1.5rem;
    }

    .doc-nav .nav-content .nav-label {
      display: inline-block;
      position: relative;
      padding: 2px 0 2px 20px;
      margin-bottom: 4px;
    }

    .doc-nav .nav-content .nav-sub-label {
      position: relative;
      padding: 2px 0 2px 40px;
      font-size: 14px;
    }

    .doc-nav .nav-content .nav-sub-label:hover {
      text-decoration: underline;
    }

    .doc-nav .nav-content .nav-list .nav-label.group::before {
      border-bottom: 0.25rem solid transparent;
      border-left: 0.25rem solid #6e7072;
      border-right: 0;
      border-top: 0.25rem solid transparent;
      content: '';
      display: block;
      height: 0;
      left: 0.5rem;
      position: absolute;
      top: 0.625rem;
      transition: transform 0.1s linear;
      width: 0;
    }

    .doc-nav .nav-content .nav-list .nav-label.group.active::before {
      transform: rotate(90deg);
    }

    /* doc content */
    .container .doc-content {
      position: fixed;
      height: 100%;
      width: calc(100% - 80px - 40px - 30px - 240px);
      right: 0%;
      overflow-y: auto;
    }

    .doc-title {
      border-bottom: 1px solid #dcdee0;
      font-size: 22px;
      margin: 8px 0 0;
      padding-bottom: 16px;
    }

    .doc-content h3 {
      font-size: 24px;
      font-weight: 600;
      margin: 24px 0;
    }

    .doc-content h4 {
      font-size: 22px;
      font-weight: 500;
      margin: 30px 0 8px;
    }

    .doc-content h4 span {
      color: #007d9c;
    }

    .doc-content .doc-declare {
      background-color: #fafafa;
      border-radius: 5px;
      border: 1px solid #ccc;
      font-size: 14px;
      overflow-x: auto;
      padding: 10px;
      tab-size: 4;
      line-height: 20px;
    }

    .doc-content .doc-comment {
      font-size: 16px;
      margin: 16px 0;
      line-height: 24px;
      word-break: break-word;
    }
  </style>

</head>
<body>
  <div class="container">
    <div class="doc-nav">
      <a href="#Documentation" class="nav-header">Documentation</a>
      <nav class="nav-content">
        <ul class="nav-list">
          <li>
            <a href="#includes" class="nav-label">Includes</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#lwip/opt.h" class="nav-sub-label">lwip/opt.h</a>
              </li>
      

              <li>
                <a href="#lwip/arch.h" class="nav-sub-label">lwip/arch.h</a>
              </li>
      

              <li>
                <a href="#lwip/netbuf.h" class="nav-sub-label">lwip/netbuf.h</a>
              </li>
      

              <li>
                <a href="#lwip/sys.h" class="nav-sub-label">lwip/sys.h</a>
              </li>
      

              <li>
                <a href="#lwip/ip_addr.h" class="nav-sub-label">lwip/ip_addr.h</a>
              </li>
      

              <li>
                <a href="#lwip/err.h" class="nav-sub-label">lwip/err.h</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#macros" class="nav-label">Macros</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#LWIP_HDR_API_H" class="nav-sub-label">LWIP_HDR_API_H</a>
              </li>
      

              <li>
                <a href="#NETCONN_NOFLAG" class="nav-sub-label">NETCONN_NOFLAG</a>
              </li>
      

              <li>
                <a href="#NETCONN_NOCOPY" class="nav-sub-label">NETCONN_NOCOPY</a>
              </li>
      

              <li>
                <a href="#NETCONN_COPY" class="nav-sub-label">NETCONN_COPY</a>
              </li>
      

              <li>
                <a href="#NETCONN_MORE" class="nav-sub-label">NETCONN_MORE</a>
              </li>
      

              <li>
                <a href="#NETCONN_DONTBLOCK" class="nav-sub-label">NETCONN_DONTBLOCK</a>
              </li>
      

              <li>
                <a href="#NETCONN_NOAUTORCVD" class="nav-sub-label">NETCONN_NOAUTORCVD</a>
              </li>
      

              <li>
                <a href="#NETCONN_NOFIN" class="nav-sub-label">NETCONN_NOFIN</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_MBOXCLOSED" class="nav-sub-label">NETCONN_FLAG_MBOXCLOSED</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_NON_BLOCKING" class="nav-sub-label">NETCONN_FLAG_NON_BLOCKING</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_IN_NONBLOCKING_CONNECT" class="nav-sub-label">NETCONN_FLAG_IN_NONBLOCKING_CONNECT</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_MBOXINVALID" class="nav-sub-label">NETCONN_FLAG_MBOXINVALID</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_CHECK_WRITESPACE" class="nav-sub-label">NETCONN_FLAG_CHECK_WRITESPACE</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_IPV6_V6ONLY" class="nav-sub-label">NETCONN_FLAG_IPV6_V6ONLY</a>
              </li>
      

              <li>
                <a href="#NETCONN_FLAG_PKTINFO" class="nav-sub-label">NETCONN_FLAG_PKTINFO</a>
              </li>
      

              <li>
                <a href="#NETCONN_FIN_RX_PENDING" class="nav-sub-label">NETCONN_FIN_RX_PENDING</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_GROUP(t)" class="nav-sub-label">NETCONNTYPE_GROUP(t)</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_DATAGRAM(t)" class="nav-sub-label">NETCONNTYPE_DATAGRAM(t)</a>
              </li>
      

              <li>
                <a href="#NETCONN_TYPE_IPV6" class="nav-sub-label">NETCONN_TYPE_IPV6</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_ISIPV6(t)" class="nav-sub-label">NETCONNTYPE_ISIPV6(t)</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_ISUDPLITE(t)" class="nav-sub-label">NETCONNTYPE_ISUDPLITE(t)</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_ISUDPNOCHKSUM(t)" class="nav-sub-label">NETCONNTYPE_ISUDPNOCHKSUM(t)</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_ISIPV6(t)" class="nav-sub-label">NETCONNTYPE_ISIPV6(t)</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_ISUDPLITE(t)" class="nav-sub-label">NETCONNTYPE_ISUDPLITE(t)</a>
              </li>
      

              <li>
                <a href="#NETCONNTYPE_ISUDPNOCHKSUM(t)" class="nav-sub-label">NETCONNTYPE_ISUDPNOCHKSUM(t)</a>
              </li>
      

              <li>
                <a href="#NETCONN_DNS_DEFAULT" class="nav-sub-label">NETCONN_DNS_DEFAULT</a>
              </li>
      

              <li>
                <a href="#NETCONN_DNS_IPV4" class="nav-sub-label">NETCONN_DNS_IPV4</a>
              </li>
      

              <li>
                <a href="#NETCONN_DNS_IPV6" class="nav-sub-label">NETCONN_DNS_IPV6</a>
              </li>
      

              <li>
                <a href="#NETCONN_DNS_IPV4_IPV6" class="nav-sub-label">NETCONN_DNS_IPV4_IPV6</a>
              </li>
      

              <li>
                <a href="#NETCONN_DNS_IPV6_IPV4" class="nav-sub-label">NETCONN_DNS_IPV6_IPV4</a>
              </li>
      

              <li>
                <a href="#API_EVENT(c,e,l)" class="nav-sub-label">API_EVENT(c,e,l)</a>
              </li>
      

              <li>
                <a href="#netconn_new(t)" class="nav-sub-label">netconn_new(t)</a>
              </li>
      

              <li>
                <a href="#netconn_new_with_callback(t, c)" class="nav-sub-label">netconn_new_with_callback(t, c)</a>
              </li>
      

              <li>
                <a href="#netconn_type(conn)" class="nav-sub-label">netconn_type(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_peer(c,i,p)" class="nav-sub-label">netconn_peer(c,i,p)</a>
              </li>
      

              <li>
                <a href="#netconn_addr(c,i,p)" class="nav-sub-label">netconn_addr(c,i,p)</a>
              </li>
      

              <li>
                <a href="#netconn_listen(conn)" class="nav-sub-label">netconn_listen(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_write(conn, dataptr, size, apiflags)" class="nav-sub-label">netconn_write(conn, dataptr, size, apiflags)</a>
              </li>
      

              <li>
                <a href="#netconn_gethostbyname(name, addr)" class="nav-sub-label">netconn_gethostbyname(name, addr)</a>
              </li>
      

              <li>
                <a href="#netconn_gethostbyname_addrtype(name, addr, dns_addrtype)" class="nav-sub-label">netconn_gethostbyname_addrtype(name, addr, dns_addrtype)</a>
              </li>
      

              <li>
                <a href="#netconn_recv_bufsize(conn)" class="nav-sub-label">netconn_recv_bufsize(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_set_flags(conn, set_flags)" class="nav-sub-label">netconn_set_flags(conn, set_flags)</a>
              </li>
      

              <li>
                <a href="#netconn_clear_flags(conn, clr_flags)" class="nav-sub-label">netconn_clear_flags(conn, clr_flags)</a>
              </li>
      

              <li>
                <a href="#netconn_is_flag_set(conn, flag)" class="nav-sub-label">netconn_is_flag_set(conn, flag)</a>
              </li>
      

              <li>
                <a href="#netconn_set_nonblocking(conn, val)" class="nav-sub-label">netconn_set_nonblocking(conn, val)</a>
              </li>
      

              <li>
                <a href="#netconn_is_nonblocking(conn)" class="nav-sub-label">netconn_is_nonblocking(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_set_ipv6only(conn, val)" class="nav-sub-label">netconn_set_ipv6only(conn, val)</a>
              </li>
      

              <li>
                <a href="#netconn_get_ipv6only(conn)" class="nav-sub-label">netconn_get_ipv6only(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_set_sendtimeout(conn, timeout)" class="nav-sub-label">netconn_set_sendtimeout(conn, timeout)</a>
              </li>
      

              <li>
                <a href="#netconn_get_sendtimeout(conn)" class="nav-sub-label">netconn_get_sendtimeout(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_set_recvtimeout(conn, timeout)" class="nav-sub-label">netconn_set_recvtimeout(conn, timeout)</a>
              </li>
      

              <li>
                <a href="#netconn_get_recvtimeout(conn)" class="nav-sub-label">netconn_get_recvtimeout(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_set_recvbufsize(conn, recvbufsize)" class="nav-sub-label">netconn_set_recvbufsize(conn, recvbufsize)</a>
              </li>
      

              <li>
                <a href="#netconn_get_recvbufsize(conn)" class="nav-sub-label">netconn_get_recvbufsize(conn)</a>
              </li>
      

              <li>
                <a href="#netconn_thread_init" class="nav-sub-label">netconn_thread_init</a>
              </li>
      

              <li>
                <a href="#netconn_thread_cleanup" class="nav-sub-label">netconn_thread_cleanup</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#functions" class="nav-label">Functions</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#netconn_prepare_delete" class="nav-sub-label">netconn_prepare_delete</a>
              </li>
      

              <li>
                <a href="#netconn_delete" class="nav-sub-label">netconn_delete</a>
              </li>
      

              <li>
                <a href="#netconn_getaddr" class="nav-sub-label">netconn_getaddr</a>
              </li>
      

              <li>
                <a href="#netconn_bind" class="nav-sub-label">netconn_bind</a>
              </li>
      

              <li>
                <a href="#netconn_bind_if" class="nav-sub-label">netconn_bind_if</a>
              </li>
      

              <li>
                <a href="#netconn_connect" class="nav-sub-label">netconn_connect</a>
              </li>
      

              <li>
                <a href="#netconn_disconnect" class="nav-sub-label">netconn_disconnect</a>
              </li>
      

              <li>
                <a href="#netconn_listen_with_backlog" class="nav-sub-label">netconn_listen_with_backlog</a>
              </li>
      

              <li>
                <a href="#netconn_accept" class="nav-sub-label">netconn_accept</a>
              </li>
      

              <li>
                <a href="#netconn_recv" class="nav-sub-label">netconn_recv</a>
              </li>
      

              <li>
                <a href="#netconn_recv_udp_raw_netbuf" class="nav-sub-label">netconn_recv_udp_raw_netbuf</a>
              </li>
      

              <li>
                <a href="#netconn_recv_udp_raw_netbuf_flags" class="nav-sub-label">netconn_recv_udp_raw_netbuf_flags</a>
              </li>
      

              <li>
                <a href="#netconn_recv_tcp_pbuf" class="nav-sub-label">netconn_recv_tcp_pbuf</a>
              </li>
      

              <li>
                <a href="#netconn_recv_tcp_pbuf_flags" class="nav-sub-label">netconn_recv_tcp_pbuf_flags</a>
              </li>
      

              <li>
                <a href="#netconn_tcp_recvd" class="nav-sub-label">netconn_tcp_recvd</a>
              </li>
      

              <li>
                <a href="#netconn_sendto" class="nav-sub-label">netconn_sendto</a>
              </li>
      

              <li>
                <a href="#netconn_send" class="nav-sub-label">netconn_send</a>
              </li>
      

              <li>
                <a href="#netconn_write_partly" class="nav-sub-label">netconn_write_partly</a>
              </li>
      

              <li>
                <a href="#netconn_write_vectors_partly" class="nav-sub-label">netconn_write_vectors_partly</a>
              </li>
      

              <li>
                <a href="#netconn_close" class="nav-sub-label">netconn_close</a>
              </li>
      

              <li>
                <a href="#netconn_shutdown" class="nav-sub-label">netconn_shutdown</a>
              </li>
      

              <li>
                <a href="#netconn_join_leave_group" class="nav-sub-label">netconn_join_leave_group</a>
              </li>
      

              <li>
                <a href="#netconn_join_leave_group_netif" class="nav-sub-label">netconn_join_leave_group_netif</a>
              </li>
      

              <li>
                <a href="#netconn_gethostbyname_addrtype" class="nav-sub-label">netconn_gethostbyname_addrtype</a>
              </li>
      

              <li>
                <a href="#netconn_gethostbyname" class="nav-sub-label">netconn_gethostbyname</a>
              </li>
      

              <li>
                <a href="#netconn_err" class="nav-sub-label">netconn_err</a>
              </li>
      

              <li>
                <a href="#netconn_thread_init" class="nav-sub-label">netconn_thread_init</a>
              </li>
      

              <li>
                <a href="#netconn_thread_cleanup" class="nav-sub-label">netconn_thread_cleanup</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#vars" class="nav-label">Vars</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#ip_pcb" class="nav-sub-label">ip_pcb</a>
              </li>
      

              <li>
                <a href="#tcp_pcb" class="nav-sub-label">tcp_pcb</a>
              </li>
      

              <li>
                <a href="#udp_pcb" class="nav-sub-label">udp_pcb</a>
              </li>
      

              <li>
                <a href="#raw_pcb" class="nav-sub-label">raw_pcb</a>
              </li>
      

              <li>
                <a href="#netconn" class="nav-sub-label">netconn</a>
              </li>
      

              <li>
                <a href="#api_msg" class="nav-sub-label">api_msg</a>
              </li>
      

              <li>
                <a href="#pending_err" class="nav-sub-label">pending_err</a>
              </li>
      

              <li>
                <a href="#op_completed" class="nav-sub-label">op_completed</a>
              </li>
      

              <li>
                <a href="#recvmbox" class="nav-sub-label">recvmbox</a>
              </li>
      

              <li>
                <a href="#acceptmbox" class="nav-sub-label">acceptmbox</a>
              </li>
      

              <li>
                <a href="#mbox_threads_waiting" class="nav-sub-label">mbox_threads_waiting</a>
              </li>
      

              <li>
                <a href="#socket" class="nav-sub-label">socket</a>
              </li>
      

              <li>
                <a href="#s32_t" class="nav-sub-label">s32_t</a>
              </li>
      

              <li>
                <a href="#recv_timeout" class="nav-sub-label">recv_timeout</a>
              </li>
      

              <li>
                <a href="#recv_bufsize" class="nav-sub-label">recv_bufsize</a>
              </li>
      

              <li>
                <a href="#recv_avail" class="nav-sub-label">recv_avail</a>
              </li>
      

              <li>
                <a href="#linger" class="nav-sub-label">linger</a>
              </li>
      

              <li>
                <a href="#flags" class="nav-sub-label">flags</a>
              </li>
      

              <li>
                <a href="#api_msg" class="nav-sub-label">api_msg</a>
              </li>
      

              <li>
                <a href="#callback" class="nav-sub-label">callback</a>
              </li>
      

              <li>
                <a href="#netconn" class="nav-sub-label">netconn</a>
              </li>
      
            </ul>
            
          </li>
          <li>
            <a href="#consts" class="nav-label">Consts</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#types" class="nav-label">Types</a>
            
            <ul class="nav-sub-list">
            
            </ul>
            
          </li>
          <li>
            <a href="#typedefs" class="nav-label">Typedefs</a>
             
            <ul class="nav-sub-list">

              <li>
                <a href="#netconn_callback" class="nav-sub-label">netconn_callback</a>
              </li>
      
            </ul>
            
          </li>
        </ul>
      </nav>
    </div>
    <div class="doc-content">
      <h2 id="Documentation" class="doc-title">Documentation</h2>
      <h3 id="includes">Includes</h3>
      

      <h4 id="lwip/opt.h"><span>lwip/opt.h</span></h4>
      <pre class="doc-declare"><code>#include "lwip/opt.h"
</code></pre>
      <pre class="doc-comment">#include "lwip/opt.h"
</pre>

      <h4 id="lwip/arch.h"><span>lwip/arch.h</span></h4>
      <pre class="doc-declare"><code>#include "lwip/arch.h"
</code></pre>
      <pre class="doc-comment">#include "lwip/arch.h"
</pre>

      <h4 id="lwip/netbuf.h"><span>lwip/netbuf.h</span></h4>
      <pre class="doc-declare"><code>#include "lwip/netbuf.h"
</code></pre>
      <pre class="doc-comment">#include "lwip/netbuf.h"
</pre>

      <h4 id="lwip/sys.h"><span>lwip/sys.h</span></h4>
      <pre class="doc-declare"><code>#include "lwip/sys.h"
</code></pre>
      <pre class="doc-comment">#include "lwip/sys.h"
</pre>

      <h4 id="lwip/ip_addr.h"><span>lwip/ip_addr.h</span></h4>
      <pre class="doc-declare"><code>#include "lwip/ip_addr.h"
</code></pre>
      <pre class="doc-comment">#include "lwip/ip_addr.h"
</pre>

      <h4 id="lwip/err.h"><span>lwip/err.h</span></h4>
      <pre class="doc-declare"><code>#include "lwip/err.h"
</code></pre>
      <pre class="doc-comment">#include "lwip/err.h"
</pre>
      <h3 id="macros">Macros</h3>
      

      <h4 id="LWIP_HDR_API_H">Marco <span>LWIP_HDR_API_H</span></h4>
      <pre class="doc-declare"><code>#define LWIP_HDR_API_H
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_NOFLAG">Marco <span>NETCONN_NOFLAG</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_NOFLAG     0
</code></pre>
      <pre class="doc-comment">/* Flags for netconn_write (u8_t) */</pre>

      <h4 id="NETCONN_NOCOPY">Marco <span>NETCONN_NOCOPY</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_NOCOPY     0 /* Only for source code compatibility */
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_COPY">Marco <span>NETCONN_COPY</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_COPY       1
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_MORE">Marco <span>NETCONN_MORE</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_MORE       2
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_DONTBLOCK">Marco <span>NETCONN_DONTBLOCK</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_DONTBLOCK  4
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_NOAUTORCVD">Marco <span>NETCONN_NOAUTORCVD</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_NOAUTORCVD 8 /* prevent netconn_recv_data_tcp() from updating the tcp window - must be done manually via netconn_tcp_recvd() */
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_NOFIN">Marco <span>NETCONN_NOFIN</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_NOFIN      16 /* upper layer already received data, leave FIN in queue until called again */
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_FLAG_MBOXCLOSED">Marco <span>NETCONN_FLAG_MBOXCLOSED</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_MBOXCLOSED              1
</code></pre>
      <pre class="doc-comment">/** This netconn had an error, don't block on recvmbox/acceptmbox any more */</pre>

      <h4 id="NETCONN_FLAG_NON_BLOCKING">Marco <span>NETCONN_FLAG_NON_BLOCKING</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_NON_BLOCKING            2
</code></pre>
      <pre class="doc-comment">/** Should this netconn avoid blocking? */</pre>

      <h4 id="NETCONN_FLAG_IN_NONBLOCKING_CONNECT">Marco <span>NETCONN_FLAG_IN_NONBLOCKING_CONNECT</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_IN_NONBLOCKING_CONNECT  4
</code></pre>
      <pre class="doc-comment">/** Was the last connect action a non-blocking one? */</pre>

      <h4 id="NETCONN_FLAG_MBOXINVALID">Marco <span>NETCONN_FLAG_MBOXINVALID</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_MBOXINVALID             8
</code></pre>
      <pre class="doc-comment">/** The mbox of this netconn is being deallocated, don't use it anymore */</pre>

      <h4 id="NETCONN_FLAG_CHECK_WRITESPACE">Marco <span>NETCONN_FLAG_CHECK_WRITESPACE</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_CHECK_WRITESPACE        16
</code></pre>
      <pre class="doc-comment">/** If a nonblocking write has been rejected before, poll_tcp needs to
    check if the netconn is writable again */</pre>

      <h4 id="NETCONN_FLAG_IPV6_V6ONLY">Marco <span>NETCONN_FLAG_IPV6_V6ONLY</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_IPV6_V6ONLY             32
</code></pre>
      <pre class="doc-comment">/** If this flag is set then only IPv6 communication is allowed on the
    netconn. As per RFC#3493 this features defaults to OFF allowing
    dual-stack usage by default. */</pre>

      <h4 id="NETCONN_FLAG_PKTINFO">Marco <span>NETCONN_FLAG_PKTINFO</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FLAG_PKTINFO                 64
</code></pre>
      <pre class="doc-comment">/** Received packet info will be recorded for this netconn */</pre>

      <h4 id="NETCONN_FIN_RX_PENDING">Marco <span>NETCONN_FIN_RX_PENDING</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_FIN_RX_PENDING               128
</code></pre>
      <pre class="doc-comment">/** A FIN has been received but not passed to the application yet */</pre>

      <h4 id="NETCONNTYPE_GROUP(t)">Marco <span>NETCONNTYPE_GROUP(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_GROUP(t)        ((t)&240)
</code></pre>
      <pre class="doc-comment">/* Helpers to process several netconn_types by the same code */</pre>

      <h4 id="NETCONNTYPE_DATAGRAM(t)">Marco <span>NETCONNTYPE_DATAGRAM(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_DATAGRAM(t)     ((t)&0xE0)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_TYPE_IPV6">Marco <span>NETCONN_TYPE_IPV6</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_TYPE_IPV6           8
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONNTYPE_ISIPV6(t)">Marco <span>NETCONNTYPE_ISIPV6(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_ISIPV6(t)       (((t)&NETCONN_TYPE_IPV6) != 0)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONNTYPE_ISUDPLITE(t)">Marco <span>NETCONNTYPE_ISUDPLITE(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_ISUDPLITE(t)    (((t)&243) == NETCONN_UDPLITE)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONNTYPE_ISUDPNOCHKSUM(t)">Marco <span>NETCONNTYPE_ISUDPNOCHKSUM(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_ISUDPNOCHKSUM(t) (((t)&243) == NETCONN_UDPNOCHKSUM)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONNTYPE_ISIPV6(t)">Marco <span>NETCONNTYPE_ISIPV6(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_ISIPV6(t)       (0)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONNTYPE_ISUDPLITE(t)">Marco <span>NETCONNTYPE_ISUDPLITE(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_ISUDPLITE(t)    ((t) == NETCONN_UDPLITE)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONNTYPE_ISUDPNOCHKSUM(t)">Marco <span>NETCONNTYPE_ISUDPNOCHKSUM(t)</span></h4>
      <pre class="doc-declare"><code>#define NETCONNTYPE_ISUDPNOCHKSUM(t) ((t) == NETCONN_UDPNOCHKSUM)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_DNS_DEFAULT">Marco <span>NETCONN_DNS_DEFAULT</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_DNS_DEFAULT  NETCONN_DNS_IPV4_IPV6
</code></pre>
      <pre class="doc-comment">/* Used for netconn_gethostbyname_addrtype(), these should match the DNS_ADDRTYPE defines in dns.h */</pre>

      <h4 id="NETCONN_DNS_IPV4">Marco <span>NETCONN_DNS_IPV4</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_DNS_IPV4     0
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_DNS_IPV6">Marco <span>NETCONN_DNS_IPV6</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_DNS_IPV6     1
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_DNS_IPV4_IPV6">Marco <span>NETCONN_DNS_IPV4_IPV6</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_DNS_IPV4_IPV6 2 /* try to resolve IPv4 first, try IPv6 if IPv4 fails only */
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="NETCONN_DNS_IPV6_IPV4">Marco <span>NETCONN_DNS_IPV6_IPV4</span></h4>
      <pre class="doc-declare"><code>#define NETCONN_DNS_IPV6_IPV4 3 /* try to resolve IPv6 first, try IPv4 if IPv6 fails only */
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="API_EVENT(c,e,l)">Marco <span>API_EVENT(c,e,l)</span></h4>
      <pre class="doc-declare"><code>#define API_EVENT(c,e,l) if (c->callback) {        \
                          (*c->callback)(c, e, l); \
                        }
</code></pre>
      <pre class="doc-comment">/** Register an Network connection event */</pre>

      <h4 id="netconn_new(t)">Marco <span>netconn_new(t)</span></h4>
      <pre class="doc-declare"><code>#define netconn_new(t)                 netconn_new_with_proto_and_callback(t, 0, NULL)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_common
 * Create new netconn connection
 * @param t @ref netconn_type */</pre>

      <h4 id="netconn_new_with_callback(t, c)">Marco <span>netconn_new_with_callback(t, c)</span></h4>
      <pre class="doc-declare"><code>#define netconn_new_with_callback(t, c) netconn_new_with_proto_and_callback(t, 0, c)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_type(conn)">Marco <span>netconn_type(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_type(conn) (conn->type)
</code></pre>
      <pre class="doc-comment">/** Get the type of a netconn (as enum netconn_type). */</pre>

      <h4 id="netconn_peer(c,i,p)">Marco <span>netconn_peer(c,i,p)</span></h4>
      <pre class="doc-declare"><code>#define netconn_peer(c,i,p) netconn_getaddr(c,i,p,0)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_common */</pre>

      <h4 id="netconn_addr(c,i,p)">Marco <span>netconn_addr(c,i,p)</span></h4>
      <pre class="doc-declare"><code>#define netconn_addr(c,i,p) netconn_getaddr(c,i,p,1)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_common */</pre>

      <h4 id="netconn_listen(conn)">Marco <span>netconn_listen(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_listen(conn) netconn_listen_with_backlog(conn, TCP_DEFAULT_LISTEN_BACKLOG)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_tcp */</pre>

      <h4 id="netconn_write(conn, dataptr, size, apiflags)">Marco <span>netconn_write(conn, dataptr, size, apiflags)</span></h4>
      <pre class="doc-declare"><code>#define netconn_write(conn, dataptr, size, apiflags) \
         netconn_write_partly(conn, dataptr, size, apiflags, NULL)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_tcp */</pre>

      <h4 id="netconn_gethostbyname(name, addr)">Marco <span>netconn_gethostbyname(name, addr)</span></h4>
      <pre class="doc-declare"><code>#define netconn_gethostbyname(name, addr) netconn_gethostbyname_addrtype(name, addr, NETCONN_DNS_DEFAULT)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_gethostbyname_addrtype(name, addr, dns_addrtype)">Marco <span>netconn_gethostbyname_addrtype(name, addr, dns_addrtype)</span></h4>
      <pre class="doc-declare"><code>#define netconn_gethostbyname_addrtype(name, addr, dns_addrtype) netconn_gethostbyname(name, addr)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_recv_bufsize(conn)">Marco <span>netconn_recv_bufsize(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_recv_bufsize(conn)     ((conn)->recv_bufsize)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_set_flags(conn, set_flags)">Marco <span>netconn_set_flags(conn, set_flags)</span></h4>
      <pre class="doc-declare"><code>#define netconn_set_flags(conn, set_flags)    do { (conn)->flags = (u8_t)((conn)->flags | (set_flags)); } while(0)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_clear_flags(conn, clr_flags)">Marco <span>netconn_clear_flags(conn, clr_flags)</span></h4>
      <pre class="doc-declare"><code>#define netconn_clear_flags(conn, clr_flags)  do { (conn)->flags = (u8_t)((conn)->flags & (u8_t)(~(clr_flags) & 255)); } while(0)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_is_flag_set(conn, flag)">Marco <span>netconn_is_flag_set(conn, flag)</span></h4>
      <pre class="doc-declare"><code>#define netconn_is_flag_set(conn, flag)       (((conn)->flags & (flag)) != 0)
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_set_nonblocking(conn, val)">Marco <span>netconn_set_nonblocking(conn, val)</span></h4>
      <pre class="doc-declare"><code>#define netconn_set_nonblocking(conn, val) do { if(val) { \
 netconn_set_flags(conn, NETCONN_FLAG_NON_BLOCKING); \
} else { \
 netconn_clear_flags(conn, NETCONN_FLAG_NON_BLOCKING); }} while(0)
</code></pre>
      <pre class="doc-comment">/** Set the blocking status of netconn calls (@todo: write/send is missing) */</pre>

      <h4 id="netconn_is_nonblocking(conn)">Marco <span>netconn_is_nonblocking(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_is_nonblocking(conn)       (((conn)->flags & NETCONN_FLAG_NON_BLOCKING) != 0)
</code></pre>
      <pre class="doc-comment">/** Get the blocking status of netconn calls (@todo: write/send is missing) */</pre>

      <h4 id="netconn_set_ipv6only(conn, val)">Marco <span>netconn_set_ipv6only(conn, val)</span></h4>
      <pre class="doc-declare"><code>#define netconn_set_ipv6only(conn, val) do { if(val) { \
 netconn_set_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); \
} else { \
 netconn_clear_flags(conn, NETCONN_FLAG_IPV6_V6ONLY); }} while(0)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_common
 * TCP: Set the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY)
 */</pre>

      <h4 id="netconn_get_ipv6only(conn)">Marco <span>netconn_get_ipv6only(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_get_ipv6only(conn)       (((conn)->flags & NETCONN_FLAG_IPV6_V6ONLY) != 0)
</code></pre>
      <pre class="doc-comment">/** @ingroup netconn_common
 * TCP: Get the IPv6 ONLY status of netconn calls (see NETCONN_FLAG_IPV6_V6ONLY)
 */</pre>

      <h4 id="netconn_set_sendtimeout(conn, timeout)">Marco <span>netconn_set_sendtimeout(conn, timeout)</span></h4>
      <pre class="doc-declare"><code>#define netconn_set_sendtimeout(conn, timeout)     ((conn)->send_timeout = (timeout))
</code></pre>
      <pre class="doc-comment">/** Set the send timeout in milliseconds */</pre>

      <h4 id="netconn_get_sendtimeout(conn)">Marco <span>netconn_get_sendtimeout(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_get_sendtimeout(conn)              ((conn)->send_timeout)
</code></pre>
      <pre class="doc-comment">/** Get the send timeout in milliseconds */</pre>

      <h4 id="netconn_set_recvtimeout(conn, timeout)">Marco <span>netconn_set_recvtimeout(conn, timeout)</span></h4>
      <pre class="doc-declare"><code>#define netconn_set_recvtimeout(conn, timeout)     ((conn)->recv_timeout = (timeout))
</code></pre>
      <pre class="doc-comment">/** Set the receive timeout in milliseconds */</pre>

      <h4 id="netconn_get_recvtimeout(conn)">Marco <span>netconn_get_recvtimeout(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_get_recvtimeout(conn)              ((conn)->recv_timeout)
</code></pre>
      <pre class="doc-comment">/** Get the receive timeout in milliseconds */</pre>

      <h4 id="netconn_set_recvbufsize(conn, recvbufsize)">Marco <span>netconn_set_recvbufsize(conn, recvbufsize)</span></h4>
      <pre class="doc-declare"><code>#define netconn_set_recvbufsize(conn, recvbufsize) ((conn)->recv_bufsize = (recvbufsize))
</code></pre>
      <pre class="doc-comment">/** Set the receive buffer in bytes */</pre>

      <h4 id="netconn_get_recvbufsize(conn)">Marco <span>netconn_get_recvbufsize(conn)</span></h4>
      <pre class="doc-declare"><code>#define netconn_get_recvbufsize(conn)              ((conn)->recv_bufsize)
</code></pre>
      <pre class="doc-comment">/** Get the receive buffer in bytes */</pre>

      <h4 id="netconn_thread_init">Marco <span>netconn_thread_init</span></h4>
      <pre class="doc-declare"><code>#define netconn_thread_init 
</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_thread_cleanup">Marco <span>netconn_thread_cleanup</span></h4>
      <pre class="doc-declare"><code>#define netconn_thread_cleanup 
</code></pre>
      <pre class="doc-comment"></pre>
      <h3 id="functions">Functions</h3>
      

      <h4 id="netconn_prepare_delete">Func <span>netconn_prepare_delete</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_prepare_delete(struct netconn *conn);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_delete">Func <span>netconn_delete</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_delete(struct netconn *conn);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_getaddr">Func <span>netconn_getaddr</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_getaddr(struct netconn *conn, ip_addr_t *addr,
                       u16_t *port, u8_t local);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_bind">Func <span>netconn_bind</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_bind(struct netconn *conn, const ip_addr_t *addr, u16_t port);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_bind_if">Func <span>netconn_bind_if</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_bind_if(struct netconn *conn, u8_t if_idx);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_connect">Func <span>netconn_connect</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_connect(struct netconn *conn, const ip_addr_t *addr, u16_t port);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_disconnect">Func <span>netconn_disconnect</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_disconnect (struct netconn *conn);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_listen_with_backlog">Func <span>netconn_listen_with_backlog</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_listen_with_backlog(struct netconn *conn, u8_t backlog);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_accept">Func <span>netconn_accept</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_accept(struct netconn *conn, struct netconn **new_conn);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_recv">Func <span>netconn_recv</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_recv(struct netconn *conn, struct netbuf **new_buf);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_recv_udp_raw_netbuf">Func <span>netconn_recv_udp_raw_netbuf</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_recv_udp_raw_netbuf(struct netconn *conn, struct netbuf **new_buf);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_recv_udp_raw_netbuf_flags">Func <span>netconn_recv_udp_raw_netbuf_flags</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_recv_udp_raw_netbuf_flags(struct netconn *conn, struct netbuf **new_buf, u8_t apiflags);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_recv_tcp_pbuf">Func <span>netconn_recv_tcp_pbuf</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_recv_tcp_pbuf(struct netconn *conn, struct pbuf **new_buf);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_recv_tcp_pbuf_flags">Func <span>netconn_recv_tcp_pbuf_flags</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_recv_tcp_pbuf_flags(struct netconn *conn, struct pbuf **new_buf, u8_t apiflags);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_tcp_recvd">Func <span>netconn_tcp_recvd</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_tcp_recvd(struct netconn *conn, size_t len);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_sendto">Func <span>netconn_sendto</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_sendto(struct netconn *conn, struct netbuf *buf,
                            const ip_addr_t *addr, u16_t port);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_send">Func <span>netconn_send</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_send(struct netconn *conn, struct netbuf *buf);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_write_partly">Func <span>netconn_write_partly</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_write_partly(struct netconn *conn, const void *dataptr, size_t size,
                            u8_t apiflags, size_t *bytes_written);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_write_vectors_partly">Func <span>netconn_write_vectors_partly</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_write_vectors_partly(struct netconn *conn, struct netvector *vectors, u16_t vectorcnt,
                                    u8_t apiflags, size_t *bytes_written);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_close">Func <span>netconn_close</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_close(struct netconn *conn);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_shutdown">Func <span>netconn_shutdown</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_shutdown(struct netconn *conn, u8_t shut_rx, u8_t shut_tx);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_join_leave_group">Func <span>netconn_join_leave_group</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_join_leave_group(struct netconn *conn, const ip_addr_t *multiaddr,
                            const ip_addr_t *netif_addr, enum netconn_igmp join_or_leave);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_join_leave_group_netif">Func <span>netconn_join_leave_group_netif</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_join_leave_group_netif(struct netconn *conn, const ip_addr_t *multiaddr,
                            u8_t if_idx, enum netconn_igmp join_or_leave);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_gethostbyname_addrtype">Func <span>netconn_gethostbyname_addrtype</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_gethostbyname_addrtype(const char *name, ip_addr_t *addr, u8_t dns_addrtype);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_gethostbyname">Func <span>netconn_gethostbyname</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_gethostbyname(const char *name, ip_addr_t *addr);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_err">Func <span>netconn_err</span></h4>
      <pre class="doc-declare"><code>err_t  netconn_err(struct netconn *conn);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_thread_init">Func <span>netconn_thread_init</span></h4>
      <pre class="doc-declare"><code>err_t netconn_thread_init(void *ptask);</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn_thread_cleanup">Func <span>netconn_thread_cleanup</span></h4>
      <pre class="doc-declare"><code>err_t netconn_thread_cleanup(void *ptask);</code></pre>
      <pre class="doc-comment"></pre>
      <h3 id="vars">Vars</h3>
      

      <h4 id="ip_pcb">Variable <span>ip_pcb</span></h4>
      <pre class="doc-declare"><code>struct ip_pcb;</code></pre>
      <pre class="doc-comment">/* forward-declare some structs to avoid to include their headers */</pre>

      <h4 id="tcp_pcb">Variable <span>tcp_pcb</span></h4>
      <pre class="doc-declare"><code>struct tcp_pcb;</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="udp_pcb">Variable <span>udp_pcb</span></h4>
      <pre class="doc-declare"><code>struct udp_pcb;</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="raw_pcb">Variable <span>raw_pcb</span></h4>
      <pre class="doc-declare"><code>struct raw_pcb;</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="netconn">Variable <span>netconn</span></h4>
      <pre class="doc-declare"><code>struct netconn;</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="api_msg">Variable <span>api_msg</span></h4>
      <pre class="doc-declare"><code>struct api_msg;</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="pending_err">Variable <span>pending_err</span></h4>
      <pre class="doc-declare"><code>err_t pending_err;</code></pre>
      <pre class="doc-comment">/** the last asynchronous unreported error this netconn had */</pre>

      <h4 id="op_completed">Variable <span>op_completed</span></h4>
      <pre class="doc-declare"><code>sys_sem_t op_completed;</code></pre>
      <pre class="doc-comment">/** sem that is used to synchronously execute functions in the core context */</pre>

      <h4 id="recvmbox">Variable <span>recvmbox</span></h4>
      <pre class="doc-declare"><code>sys_mbox_t recvmbox;</code></pre>
      <pre class="doc-comment">/** mbox where received packets are stored until they are fetched
      by the netconn application thread (can grow quite big) */</pre>

      <h4 id="acceptmbox">Variable <span>acceptmbox</span></h4>
      <pre class="doc-declare"><code>sys_mbox_t acceptmbox;</code></pre>
      <pre class="doc-comment">/** mbox where new connections are stored until processed
      by the application thread */</pre>

      <h4 id="mbox_threads_waiting">Variable <span>mbox_threads_waiting</span></h4>
      <pre class="doc-declare"><code>int mbox_threads_waiting;</code></pre>
      <pre class="doc-comment">/** number of threads waiting on an mbox. This is required to unblock
      all threads when closing while threads are waiting. */</pre>

      <h4 id="socket">Variable <span>socket</span></h4>
      <pre class="doc-declare"><code>int socket;</code></pre>
      <pre class="doc-comment"></pre>

      <h4 id="s32_t">Variable <span>s32_t</span></h4>
      <pre class="doc-declare"><code>s32_t send_timeout;</code></pre>
      <pre class="doc-comment">/** timeout to wait for sending data (which means enqueueing data for sending
      in internal buffers) in milliseconds */</pre>

      <h4 id="recv_timeout">Variable <span>recv_timeout</span></h4>
      <pre class="doc-declare"><code>u32_t recv_timeout;</code></pre>
      <pre class="doc-comment">/** timeout in milliseconds to wait for new data to be received
      (or connections to arrive for listening netconns) */</pre>

      <h4 id="recv_bufsize">Variable <span>recv_bufsize</span></h4>
      <pre class="doc-declare"><code>int recv_bufsize;</code></pre>
      <pre class="doc-comment">/** maximum amount of bytes queued in recvmbox
      not used for TCP: adjust TCP_WND instead! */</pre>

      <h4 id="recv_avail">Variable <span>recv_avail</span></h4>
      <pre class="doc-declare"><code>int recv_avail;</code></pre>
      <pre class="doc-comment">/** number of bytes currently in recvmbox to be received,
      tested against recv_bufsize to limit bytes on recvmbox
      for UDP and RAW, used for FIONREAD */</pre>

      <h4 id="linger">Variable <span>linger</span></h4>
      <pre class="doc-declare"><code>s16_t linger;</code></pre>
      <pre class="doc-comment">/** values <0 mean linger is disabled, values > 0 are seconds to linger */</pre>

      <h4 id="flags">Variable <span>flags</span></h4>
      <pre class="doc-declare"><code>u8_t flags;</code></pre>
      <pre class="doc-comment">/** flags holding more netconn-internal state, see NETCONN_FLAG_* defines */</pre>

      <h4 id="api_msg">Variable <span>api_msg</span></h4>
      <pre class="doc-declare"><code>struct api_msg *current_msg;</code></pre>
      <pre class="doc-comment">/** TCP: when data passed to netconn_write doesn't fit into the send buffer,
      this temporarily stores the message.
      Also used during connect and close. */</pre>

      <h4 id="callback">Variable <span>callback</span></h4>
      <pre class="doc-declare"><code>netconn_callback callback;</code></pre>
      <pre class="doc-comment">/** A callback function that is informed about events for this netconn */</pre>

      <h4 id="netconn">Variable <span>netconn</span></h4>
      <pre class="doc-declare"><code>struct netconn *netconn_new_with_proto_and_callback(enum netconn_type t, u8_t proto,
                                            netconn_callback callback);</code></pre>
      <pre class="doc-comment"></pre>
      <h3 id="consts">Consts</h3>
      
      <h3 id="types">Types</h3>
      
      <h3 id="typedefs">Typedefs</h3>
      

      <h4 id="netconn_callback">Typedef <span>netconn_callback</span></h4>
      <pre class="doc-declare"><code>typedef void (* netconn_callback)(struct netconn *, enum netconn_evt, u16_t len);
</code></pre>
      <pre class="doc-comment">/** A callback prototype to inform about events for a netconn */</pre>
    </div>
  </body>
</html>
            